home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 3 / BBS in a box - Trilogy III.iso / Files / Prog / B-C / C++Source Code Fmtr Folder / Src / cdent.r < prev    next >
Encoding:
Text File  |  1990-12-17  |  36.2 KB  |  1,598 lines  |  [TEXT/MPS ]
  1. #include "FormatStrings.def.h"
  2.  
  3. resource 'cmdo' (128) {
  4.     {
  5.         /*
  6.         ** Main dialog
  7.         */
  8.         290,
  9.         "Reformats C/C++ source into a standard format, "
  10.         "suitable for printouts or compilation.  Reads from "
  11.         "a file or standard in and writes to standard out.",
  12.         {
  13.             NotDependent {},
  14.             VersionDialog {
  15.                 VersionString {"v1.0"},
  16.                 "Indent 1.0",
  17.                 noDialog
  18.             },
  19.  
  20.             NotDependent {},
  21.             NestedDialog {
  22.                 2,
  23.                 {24, 10, 43, 161},
  24.                 "I/O Specifications…",
  25.                 "Click this button to specify Indent's input/output "
  26.                 "files and options."
  27.             },
  28.  
  29.             /*
  30.             ** Styles
  31.             */
  32.             NotDependent {},
  33.             RadioButtons {
  34.                 {
  35.                     {67, 12, 102, 130},
  36.                     "K&R style",
  37.                     "",
  38.                     Set,
  39.                     "Format in the second edition K&R C style"
  40.                 },
  41.             },
  42.  
  43.             NotDependent {},
  44.             TextBox {
  45.                 black,
  46.                 {60, 10, 105, 161},
  47.                 "Styles"
  48.             },
  49.  
  50.  
  51.             /*
  52.             ** Line breaks
  53.             */
  54.             NotDependent {},
  55.             RadioButtons {
  56.                 {
  57.                     {123, 12, 138, 158},
  58.                     "Keep blank lines",
  59.                     "",
  60.                     Set,
  61.                     "Preserve blank lines from the source.  If set, a "
  62.                     "single newline "
  63.                     "is ignored, but two or more newlines appearing in "
  64.                     "sequence will be passed through to the output.",
  65.  
  66.                     {143, 12, 158, 158},
  67.                     "Keep all newlines",
  68.                     "-allnl",
  69.                     NotSet,
  70.                     "Preserve source newlines.  If set, then newlines in the "
  71.                     "source are preserved.  Otherwise the source is completely "
  72.                     "reformatted.",
  73.  
  74.                     {163, 12, 178, 158},
  75.                     "Keep no newlines",
  76.                     "-nonl",
  77.                     NotSet,
  78.                     "No source newlines will be passed through.  If set, only "
  79.                     "glue generated newlines will appear in the output.",
  80.                 },
  81.             },
  82.  
  83.             NotDependent {},
  84.             TextBox {
  85.                 black,
  86.                 {116, 10, 180, 161},
  87.                 "Spacing"
  88.             },
  89.  
  90.  
  91.             /*
  92.             ** Spacing
  93.             */
  94.             NotDependent {},
  95.             CheckOption {
  96.                 NotSet,
  97.                 {31, 166, 46, 315},
  98.                 "None around ops",
  99.                 "-x",
  100.                 "Suppress space around arithmetic ops +, "
  101.                 "-, *, /, %, relation ops ==, !=, <, <=, >, >=.  "
  102.                 "Normally 1 space is placed on each side."
  103.             },
  104.  
  105.             NotDependent {},
  106.             CheckOption {
  107.                 NotSet,
  108.                 {46, 166, 61, 315},
  109.                 "None around =",
  110.                 "-y",
  111.                 "Suppress space around assignment operator \"=\""
  112.             },
  113.  
  114.             NotDependent {},
  115.             CheckOption {
  116.                 NotSet,
  117.                 {61, 166, 76, 315},
  118.                 "None after commas",
  119.                 "-z",
  120.                 "Suppress space after commas."
  121.             },
  122.  
  123.             NotDependent {},
  124.             TextBox {
  125.                 black,
  126.                 {24, 164, 79, 317},
  127.                 "Spacing"
  128.             },
  129.  
  130.  
  131.             /*
  132.             ** Indent and line length
  133.             */
  134.             NotDependent {},
  135.             RegularEntry {
  136.                 "Indent value",
  137.                 {98, 167, 113, 277},
  138.                 {98, 280, 113, 310},
  139.                 "4",
  140.                 ignoreCase,
  141.                 "-indent",
  142.                 "Specifies the amount amount of tab for each indentation level."
  143.             },
  144.  
  145.             NotDependent {},
  146.             RegularEntry {
  147.                 "Line length",
  148.                 {118, 167, 133, 277},
  149.                 {118, 280, 133, 310},
  150.                 "144",
  151.                 ignoreCase,
  152.                 "-ll",
  153.                 "Set the output line width."
  154.             },
  155.  
  156.             NotDependent {},
  157.             RegularEntry {
  158.                 "Tab width",
  159.                 {138, 167, 153, 277},
  160.                 {138, 280, 153, 310},
  161.                 "4",
  162.                 ignoreCase,
  163.                 "-t",
  164.                 "Set the tab width."
  165.             },
  166.  
  167.             NotDependent {},
  168.             RegularEntry {
  169.                 "Comments",
  170.                 {158, 167, 173, 277},
  171.                 {158, 280, 173, 310},
  172.                 "48",
  173.                 ignoreCase,
  174.                 "-cc",
  175.                 "Set the column for end of line comments."
  176.             },
  177.  
  178.             NotDependent {},
  179.             TextBox {
  180.                 black,
  181.                 {87, 164, 180, 317},
  182.                 "Indenting"
  183.             },
  184.  
  185.             /*
  186.             ** Glue formats
  187.             */
  188.             NotDependent {},
  189.             NestedDialog {
  190.                 3,
  191.                 {39, 323, 58, 467},
  192.                 "Function glue…",
  193.                 "Modify the glue for function definitions"
  194.             },
  195.  
  196.             NotDependent {},
  197.             NestedDialog {
  198.                 4,
  199.                 {61, 323, 80, 467},
  200.                 "Method glue…",
  201.                 "Modify the glue for method definitions"
  202.             },
  203.  
  204.             NotDependent {},
  205.             NestedDialog {
  206.                 5,
  207.                 {83, 323, 102, 467},
  208.                 "Declaration glue…",
  209.                 "Modify the glue for declarations"
  210.             },
  211.  
  212.             NotDependent {},
  213.             NestedDialog {
  214.                 6,
  215.                 {105, 323, 124, 467},
  216.                 "Statement glue…",
  217.                 "Modify the glue for executable statements and labels"
  218.             },
  219.  
  220.             NotDependent {},
  221.             NestedDialog {
  222.                 7,
  223.                 {127, 323, 146, 467},
  224.                 "Expression glue…",
  225.                 "Modify the glue for expressions and function calls"
  226.             },
  227.  
  228.             NotDependent {},
  229.             TextBox {
  230.                 black,
  231.                 {24, 320, 180, 470},
  232.                 "Nerd glue"
  233.             },
  234.         },
  235.  
  236.  
  237.         /* #2
  238.         **    Dialog for I/O specification
  239.         */
  240.         273,
  241.         "I/O Specifications.",
  242.         {    /* array itemArray */
  243.  
  244.             NotDependent {},
  245.             RadioButtons {
  246.                 {    /* array radioArray: 2 elements */
  247.                     /* [1] */
  248.                     {13, 10, 28, 142}, "File to format:", "", Set, "Input file to be reformatted.  Standard "
  249.                     "input is not used in this case.",
  250.                     /* [2] */
  251.                     {13, 213, 28, 353}, "Redirect Standard", "", NotSet, "If the standard input file is used, then"
  252.                     " the reformatted file is always written "
  253.                     "to standard output."
  254.                 }
  255.             },
  256.  
  257.             Or {
  258.                 {    /* array OrArray: 1 elements */
  259.                     /* [1] */
  260.                     4097
  261.                 }
  262.             },
  263.             Files {
  264.                 InputFile,
  265.                 OptionalFile {
  266.                     {29, 29, 48, 29},
  267.                     {29, 29, 48, 146},
  268.                     "",
  269.                     "",
  270.                     "",
  271.                     "",
  272.                     "Specify the C/C++ source file to be reformatted.",
  273.                     dim,
  274.                     "Use Standard Input",
  275.                     "Select file to format...",
  276.                     ""
  277.                 },
  278.                 Additional {
  279.                     "",
  280.                     ".cp",
  281.                     "Only files ending in .cp",
  282.                     "All text files",
  283.                     {    /* array TypesArray: 1 elements */
  284.                         /* [1] */
  285.                         text
  286.                     }
  287.                 }
  288.             },
  289.  
  290.             Or {
  291.                 {    /* array OrArray: 1 elements */
  292.                     /* [1] */
  293.                     8193
  294.                 }
  295.             },
  296.             Redirection {
  297.                 StandardInput,
  298.                 {13, 353}
  299.             },
  300.  
  301.             Or {
  302.                 {    /* array OrArray: 1 elements */
  303.                     /* [1] */
  304.                     -6
  305.                 }
  306.             },
  307.             Redirection {
  308.                 StandardOutput,
  309.                 {50, 353}
  310.             },
  311.  
  312.             NotDependent {},
  313.             Redirection {
  314.                 DiagnosticOutput,
  315.                 {87, 353}
  316.             },
  317.  
  318.             And {
  319.                 {    /* array AndArray: 2 elements */
  320.                     /* [1] */
  321.                     2,
  322.                     /* [2] */
  323.                     -4
  324.                 }
  325.             },
  326.             Files {
  327.                 OutputFile,
  328.                 OptionalFile {
  329.                     {50, 193, 65, 266},
  330.                     {66, 193, 85, 309},
  331.                     "Output File",
  332.                     "Standard Output",
  333.                     "",
  334.                     "",
  335.                     "Formatted output is written to the specified "
  336.                     "file.  If this file is not specified "
  337.                     "standard output is used.",
  338.                     dim,
  339.                     "Output to Standard Output File",
  340.                     "Specify file for formatted output...",
  341.                     ""
  342.                 },
  343.                 NoMore {}
  344.             },
  345.  
  346.             NotDependent {},
  347.             CheckOption {
  348.                 NotSet,
  349.                 {107, 12, 122, 159},
  350.                 "Progress",
  351.                 "-p",
  352.                 "Display Indent's version and progress information "
  353.                 "on the diagnostic file."
  354.             },
  355.  
  356.             NotDependent {},
  357.             CheckOption {
  358.                 NotSet,
  359.                 {122, 12, 137, 159},
  360.                 "Trace parser",
  361.                 "-trace parse",
  362.                 "Display the actions the parser takes"
  363.             },
  364.  
  365.             NotDependent {},
  366.             CheckOption {
  367.                 NotSet,
  368.                 {137, 12, 152, 159},
  369.                 "Trace glue",
  370.                 "-trace formatting",
  371.                 "Display the actions of the formatting glue"
  372.             },
  373.         },
  374.  
  375.  
  376.         /* #3
  377.         **    Dialog for function glue
  378.         */
  379.         273,
  380.         "Function glue",
  381.         {
  382.             NotDependent {},
  383.             RegularEntry {
  384.                 "<type> • <name>…",
  385.                 {24,  10, 39, 141},
  386.                 {24, 145, 39, 250},
  387.                 FORMATSTRING_fundef2,
  388.                 ignoreCase,
  389.                 "-fundef2",
  390.                 "Specify the glue for that point between the type of the function "
  391.                 "and the name of the function.  The default is to emit a newline "
  392.                 "so that the name is the first thing on the line.",
  393.             },
  394.     
  395.             NotDependent {},
  396.             RegularEntry {
  397.                 "<name> • ( •…",
  398.                 {44,  10, 59, 141},
  399.                 {44, 145, 59, 250},
  400.                 FORMATSTRING_fundef3,
  401.                 ignoreCase,
  402.                 "-fundef3",
  403.                 "Specify the glue for the '(' in the function header.  The "
  404.                 "default is to display the '(', set the indent to the position "
  405.                 "after the '(' and indicate that this is the beginning of a "
  406.                 "line for the declarations following."
  407.             },
  408.         
  409.             NotDependent {},
  410.             RegularEntry {
  411.                 "<name> • ( •…",
  412.                 {64,  10, 79, 141},
  413.                 {64, 145, 79, 250},
  414.                 FORMATSTRING_fundef4,
  415.                 ignoreCase,
  416.                 "-fundef4",
  417.                 "Specify the glue for the ',' in the function's arguments.  The "
  418.                 "default is to display the ',' and put an optional blank after "
  419.                 "it.  If the ',' is the first item on a line, then the temporary "
  420.                 "indent is set to the column the comma is in."
  421.             },
  422.         
  423.             NotDependent {},
  424.             RegularEntry {
  425.                 "…(… • ) •…",
  426.                 {84,  10, 99, 141},
  427.                 {84, 145, 99, 250},
  428.                 FORMATSTRING_fundef6,
  429.                 ignoreCase,
  430.                 "-fundef6",
  431.                 "Specify the glue for the ')' in the function header.  The "
  432.                 "default is to display the ')'"
  433.             },
  434.  
  435.             NotDependent {},
  436.             RegularEntry {
  437.                 "…(…)… • <decl>",
  438.                 {104,  10, 119, 141},
  439.                 {104, 145, 119, 250},
  440.                 FORMATSTRING_fundef7,
  441.                 ignoreCase,
  442.                 "-fundef7",
  443.                 "Specify the glue to emit prior to each variable declaration "
  444.                 "in a pre-ANSI function definition.  The default is place each "
  445.                 "declaration flush left on a new line."
  446.             },
  447.  
  448.  
  449.             NotDependent {},
  450.             RegularEntry {
  451.                 "…(…)…• { •",
  452.                 {124,  10, 139, 141},
  453.                 {124, 145, 139, 250},
  454.                 FORMATSTRING_fundef11,
  455.                 ignoreCase,
  456.                 "-fundef11",
  457.                 "Specify the glue to emit for the opening curly in a function "
  458.                 "definition.  "
  459.                 "The default is to place the opening curly flush left on a "
  460.                 "newline with they body of the function indented."
  461.             },
  462.  
  463.             NotDependent {},
  464.             RegularEntry {
  465.                 "…(…)…{… • } •",
  466.                 {144,  10, 159, 141},
  467.                 {144, 145, 159, 250},
  468.                 FORMATSTRING_fundef12,
  469.                 ignoreCase,
  470.                 "-fundef12",
  471.                 "Specify the glue to emit for the closing curly in a function "
  472.                 "definition.  The default is to place the closing curly flush "
  473.                 "left on a newline with three blank lines following it."
  474.             },
  475.         },
  476.  
  477.  
  478.         /* #4
  479.         **    Dialog for method glue
  480.         */
  481.         273,
  482.         "Method glue",
  483.         {
  484.             NotDependent {},
  485.             RegularEntry {
  486.                 "…(…)… • : •",
  487.                 {24,  10, 39, 141},
  488.                 {24, 145, 39, 250},
  489.                 FORMATSTRING_fundef8,
  490.                 ignoreCase,
  491.                 "-fundef8",
  492.                 "Specify the glue to emit for the ':' in a method definition.  "
  493.                 "The default is to indent the ':' on a newline with all base class "
  494.                 "constructors, member variable initializations, and the body "
  495.                 "aligned with the ':'."
  496.             },
  497.  
  498.             NotDependent {},
  499.             RegularEntry {
  500.                 "…(…)… : … • , •",
  501.                 {44,  10, 59, 141},
  502.                 {44, 145, 59, 250},
  503.                 FORMATSTRING_fundef10,
  504.                 ignoreCase,
  505.                 "-fundef10",
  506.                 "Specify the glue to emit for the comma in a method's list of "
  507.                 "initializers.  The default is emit the ',' and request a newline "
  508.                 "unless the comma is the first item on the line, in which case "
  509.                 "it will have a blank emitted after it."
  510.             },
  511.  
  512.             NotDependent {},
  513.             RegularEntry {
  514.                 "…(…)… : … • { •",
  515.                 {64,  10, 79, 141},
  516.                 {64, 145, 79, 250},
  517.                 FORMATSTRING_fundef13,
  518.                 ignoreCase,
  519.                 "-fundef13",
  520.                 "Specify the glue to emit for the opening curly in a method "
  521.                 "definition.  "
  522.                 "The default is align the opening curly on a newline with the "
  523.                 "initial ':' "
  524.                 "and to have the body of the method aligned with the opening curly."
  525.             },
  526.  
  527.             NotDependent {},
  528.             RegularEntry {
  529.                 "…(…)… : …{… • } •",
  530.                 {84,  10, 99, 141},
  531.                 {84, 145, 99, 250},
  532.                 FORMATSTRING_fundef14,
  533.                 ignoreCase,
  534.                 "-fundef14",
  535.                 "Specify the glue to emit for the closing curly in a method definition.  "
  536.                 "The default is align the closing curly on a newline with the initial ':'."
  537.             },
  538.         },
  539.  
  540.  
  541.         /* #5
  542.         **    Dialog for declaration glue
  543.         */
  544.         273,
  545.         "Declaration glue",
  546.         {
  547.             NotDependent {},
  548.             RegularEntry {
  549.                 "• <decl>",
  550.                 {24,  10, 39, 141},
  551.                 {24, 145, 39, 250},
  552.                 FORMATSTRING_decl0,
  553.                 ignoreCase,
  554.                 "-decl0",
  555.                 "Specify the glue to emit prior to doing a declaration.  The "
  556.                 "default is to request the declaration to begin on a newline "
  557.                 "and for any '*' and '&' to associate with the object being "
  558.                 "declared."
  559.             },
  560.             
  561.             NotDependent {},
  562.             RegularEntry {
  563.                 "…• , •",
  564.                 {44,  10, 59, 141},
  565.                 {44, 145, 59, 250},
  566.                 FORMATSTRING_decl1,
  567.                 ignoreCase,
  568.                 "-decl1",
  569.                 "The default action for a comma in a declaration is to emit "
  570.                 "the comma with a space following it."
  571.             },
  572.             
  573.             NotDependent {},
  574.             RegularEntry {
  575.                 "…• = •",
  576.                 {64,  10, 79, 141},
  577.                 {64, 145, 79, 250},
  578.                 FORMATSTRING_decl2,
  579.                 ignoreCase,
  580.                 "-decl2",
  581.                 "Specify the glue for the '=' in an initialization.  The default "
  582.                 "is to surround it with blanks."
  583.             },
  584.             
  585.             NotDependent {},
  586.             RegularEntry {
  587.                 "…• ( •",
  588.                 {84,  10, 99, 141},
  589.                 {84, 145, 99, 250},
  590.                 FORMATSTRING_decl3,
  591.                 ignoreCase,
  592.                 "-decl3",
  593.                 "Specify the glue for an open paren in a declaration.  The "
  594.                 "default is to emit it and align all items following it with "
  595.                 "the first item following it."
  596.             },
  597.             
  598.             NotDependent {},
  599.             RegularEntry {
  600.                 "…(…• ) •",
  601.                 {104,  10, 119, 141},
  602.                 {104, 145, 119, 250},
  603.                 FORMATSTRING_decl11,
  604.                 ignoreCase,
  605.                 "-decl11",
  606.                 "Specify the glue for the closing paren in a declaration.  "
  607.                 "The default is to just emit it."
  608.             },
  609.             
  610.             NotDependent {},
  611.             RegularEntry {
  612.                 "…= • { •",
  613.                 {124,  10, 139, 141},
  614.                 {124, 145, 139, 250},
  615.                 FORMATSTRING_decl5,
  616.                 ignoreCase,
  617.                 "-decl5",
  618.                 "Specify the glue for the opening curly of an aggregate "
  619.                 "initializer.  The default is to emit after the '=', align "
  620.                 "all items following within the opening curly and then "
  621.                 "request a newline."
  622.             },
  623.             
  624.             NotDependent {},
  625.             RegularEntry {
  626.                 "…={… • { •",
  627.                 {144,  10, 159, 141},
  628.                 {144, 145, 159, 250},
  629.                 FORMATSTRING_decl6,
  630.                 ignoreCase,
  631.                 "-decl6",
  632.                 "Specify the glue for an aggregate initializer within a "
  633.                 "an aggregate initializer.  The default is to emit it on a "
  634.                 "newline with contents following it."
  635.             },
  636.             
  637.             NotDependent {},
  638.             RegularEntry {
  639.                 "…={…{… • } •",
  640.                 {24, 265, 39, 370},
  641.                 {24, 374, 39, 470},
  642.                 FORMATSTRING_decl7,
  643.                 ignoreCase,
  644.                 "-decl7",
  645.                 "Specify the glue for the inner closing curly of an aggregate "
  646.                 "initializer.  The default is to emit it as is."
  647.             },
  648.             
  649.             NotDependent {},
  650.             RegularEntry {
  651.                 "…={…• , •",
  652.                 {44, 265, 59, 370},
  653.                 {44, 374, 59, 470},
  654.                 FORMATSTRING_decl8,
  655.                 ignoreCase,
  656.                 "-decl8",
  657.                 "Specify the glue for the comma separating components of an "
  658.                 "aggregate initializer.  The default is to emit it with a "
  659.                 "blank following it."
  660.             },
  661.             
  662.             NotDependent {},
  663.             RegularEntry {
  664.                 "…={… • } •",
  665.                 {64, 265, 79, 370},
  666.                 {64, 374, 79, 470},
  667.                 FORMATSTRING_decl9,
  668.                 ignoreCase,
  669.                 "-decl9",
  670.                 "Specify the glue for the closing curly of an aggregate "
  671.                 "initializer.  The default is to just emit it."
  672.             },
  673.             
  674.             NotDependent {},
  675.             RegularEntry {
  676.                 "<decl> • ; •",
  677.                 {84, 265, 99, 370},
  678.                 {84, 374, 99, 470},
  679.                 FORMATSTRING_decl10,
  680.                 ignoreCase,
  681.                 "-decl10",
  682.                 "Specify the glue for the semicolon terminating a declaration.  "
  683.                 "The default is to make it adjacent to the declaration, emit it "
  684.                 "and then request a newline to follow it."
  685.             },
  686.  
  687.             NotDependent {},
  688.             NestedDialog {
  689.                 8,
  690.                 {119, 310, 138, 415},
  691.                 "struct glue…",
  692.                 "Modify the glue for struct/class/union/enum data type "
  693.                 "definition statements"
  694.             },
  695.         },
  696.  
  697.  
  698.         /* #6
  699.         **    Dialog for statement glue
  700.         */
  701.         273,
  702.         "Statement glue",
  703.         {
  704.             NotDependent {},
  705.             RegularEntry {
  706.                 "• <stmt>",
  707.                 {24,  10, 39, 141},
  708.                 {24, 145, 39, 250},
  709.                 FORMATSTRING_stmt0,
  710.                 ignoreCase,
  711.                 "-stmt0",
  712.                 "Specify the glue to emit prior to an otherwise unclassified "
  713.                 "statement (such as a function call or assignment, one which "
  714.                 "doesn't begin with a reserved word).  The default is to place "
  715.                 "the statement at the beginning of a new line."
  716.             },
  717.  
  718.             NotDependent {},
  719.             RegularEntry {
  720.                 "<stmt> • ; •",
  721.                 {44,  10, 59, 141},
  722.                 {44, 145, 59, 250},
  723.                 FORMATSTRING_stmt1,
  724.                 ignoreCase,
  725.                 "-stmt1",
  726.                 "Specify the glue to emit for the ';' terminating a statement.  "
  727.                 "The default is to request a newline after the semicolon, with no "
  728.                 "blanks separating the ';' from the item on its left."
  729.             },
  730.  
  731.             NotDependent {},
  732.             RegularEntry {
  733.                 "• label • : •",
  734.                 {64,  10, 79, 141},
  735.                 {64, 145, 79, 250},
  736.                 FORMATSTRING_label1,
  737.                 ignoreCase,
  738.                 "-label1",
  739.                 "Specify the glue to emit for a label.  The default is to "
  740.                 "place it flush left on a line by itself."
  741.             },
  742.  
  743.             NotDependent {},
  744.             RegularEntry {
  745.                 "• goto •",
  746.                 {84,  10, 99, 141},
  747.                 {84, 145, 99, 250},
  748.                 FORMATSTRING_goto1,
  749.                 ignoreCase,
  750.                 "-goto1",
  751.                 "Specify the glue to emit for a goto statement.  The default "
  752.                 "is to place it at the beginning of a newline and place a blank "
  753.                 "after the word 'goto'."
  754.             },
  755.  
  756.             NotDependent {},
  757.             RegularEntry {
  758.                 "• break •",
  759.                 {104,  10, 119, 141},
  760.                 {104, 145, 119, 250},
  761.                 FORMATSTRING_break1,
  762.                 ignoreCase,
  763.                 "-break1",
  764.                 "Specify the glue to emit for a break/continue statement.  The "
  765.                 "default is to place it on a line by itself."
  766.             },
  767.  
  768.             NotDependent {},
  769.             RegularEntry {
  770.                 "• return •",
  771.                 {124,  10, 139, 141},
  772.                 {124, 145, 139, 250},
  773.                 FORMATSTRING_return1,
  774.                 ignoreCase,
  775.                 "-return1",
  776.                 "Specify the glue to emit for a return statement.  The default "
  777.                 "is to place it at the beginning of a newline and place a blank "
  778.                 "after the word 'return'."
  779.             },
  780.  
  781.             NotDependent {},
  782.             RegularEntry {
  783.                 "• { •",
  784.                 {24, 265, 39, 370},
  785.                 {24, 374, 39, 470},
  786.                 FORMATSTRING_block1,
  787.                 ignoreCase,
  788.                 "-block1",
  789.                 "Specify the glue to emit for the opening curly of a compound "
  790.                 "statement.  The default is to emit it on a line by itself and "
  791.                 "to indent the body of the compound statement."
  792.             },
  793.  
  794.             NotDependent {},
  795.             RegularEntry {
  796.                 "• } •",
  797.                 {44, 265, 59, 370},
  798.                 {44, 374, 59, 470},
  799.                 FORMATSTRING_block2,
  800.                 ignoreCase,
  801.                 "-block2",
  802.                 "Specify the glue to emit for the closing curly of a compound "
  803.                 "statement.  The default is to align it with the opening curly "
  804.                 "on a line by itself."
  805.             },
  806.  
  807.             NotDependent {},
  808.             NestedDialog {
  809.                 9,
  810.                 {64, 270, 83, 365},
  811.                 "if…",
  812.                 "Modify the glue for if and if…else statements."
  813.             },
  814.  
  815.             NotDependent {},
  816.             NestedDialog {
  817.                 10,
  818.                 {64, 374, 83, 470},
  819.                 "switch…",
  820.                 "Modify the glue for switch statements."
  821.             },
  822.  
  823.             NotDependent {},
  824.             NestedDialog {
  825.                 11,
  826.                 {85, 270, 104, 365},
  827.                 "for…",
  828.                 "Modify the glue for switch statements."
  829.             },
  830.  
  831.             NotDependent {},
  832.             NestedDialog {
  833.                 12,
  834.                 {85, 374, 104, 470},
  835.                 "while/do…",
  836.                 "Modify the glue for while and do…while statements."
  837.             },
  838.         },
  839.  
  840.  
  841.         /* #7
  842.         **    Dialog for expression glue
  843.         */
  844.         273,
  845.         "Expression glue",
  846.         {
  847.             NotDependent {},
  848.             RegularEntry {
  849.                 "… • , •",
  850.                 {24,  10, 39, 141},
  851.                 {24, 145, 39, 250},
  852.                 FORMATSTRING_expr1,
  853.                 ignoreCase,
  854.                 "-expr1",
  855.                 "Specify the glue for the comma operator in expressions.  The "
  856.                 "default is to emit the comma with a blank following it."
  857.             },
  858.             
  859.             NotDependent {},
  860.             RegularEntry {
  861.                 "… • ? •",
  862.                 {44,  10, 59, 141},
  863.                 {44, 145, 59, 250},
  864.                 FORMATSTRING_expr2,
  865.                 ignoreCase,
  866.                 "-expr2",
  867.                 "Specify the glue for the question mark of the conditional "
  868.                 "expression.  The default is to surround the '?' with blanks."
  869.             },
  870.             
  871.             NotDependent {},
  872.             RegularEntry {
  873.                 "… ? … • : •",
  874.                 {64,  10, 79, 141},
  875.                 {64, 145, 79, 250},
  876.                 FORMATSTRING_expr3,
  877.                 ignoreCase,
  878.                 "-expr3",
  879.                 "Specify the glue for the colon of the conditional "
  880.                 "expression.  The default is to surround the ':' with blanks."
  881.             },
  882.             
  883.             NotDependent {},
  884.             RegularEntry {
  885.                 "… • op •",
  886.                 {84,  10, 99, 141},
  887.                 {84, 145, 99, 250},
  888.                 FORMATSTRING_expr4,
  889.                 ignoreCase,
  890.                 "-expr4",
  891.                 "Specify the glue for an operator.  The default is to "
  892.                 "surround the operator with blanks."
  893.             },
  894.             
  895.             NotDependent {},
  896.             RegularEntry {
  897.                 "… • ( •",
  898.                 {104,  10, 119, 141},
  899.                 {104, 145, 119, 250},
  900.                 FORMATSTRING_expr5,
  901.                 ignoreCase,
  902.                 "-expr5",
  903.                 "Specify the glue for the opening parenthesis of an expression.  "
  904.                 "The default is to emit the paren and set the indent to the first "
  905.                 "position following the paren."
  906.             },
  907.             
  908.             NotDependent {},
  909.             RegularEntry {
  910.                 "… • ) •",
  911.                 {124,  10, 139, 141},
  912.                 {124, 145, 139, 250},
  913.                 FORMATSTRING_expr7,
  914.                 ignoreCase,
  915.                 "-expr7",
  916.                 "Specify the glue for the closing paren of an expression.  The "
  917.                 "default is to emit it as is."
  918.             },
  919.             
  920.             NotDependent {},
  921.             RegularEntry {
  922.                 "… • = •",
  923.                 {24, 265, 39, 370},
  924.                 {24, 374, 39, 470},
  925.                 FORMATSTRING_expr6,
  926.                 ignoreCase,
  927.                 "-expr6",
  928.                 "Specify the glue for an assignment operator.  The default is "
  929.                 "to surround it with blanks and set the indent to the first "
  930.                 "character position following."
  931.             },
  932.             
  933.             NotDependent {},
  934.             RegularEntry {
  935.                 "… • name •",
  936.                 {44, 265, 59, 370},
  937.                 {44, 374, 59, 470},
  938.                 FORMATSTRING_expr8,
  939.                 ignoreCase,
  940.                 "-expr8",
  941.                 "Specify the glue for emitting an identifier.  The default is "
  942.                 "to emit a blank before it if the last item output was an "
  943.                 "identifier."
  944.             },
  945.         },
  946.  
  947.  
  948.         /* #8
  949.         **    Dialog for struct glue
  950.         */
  951.         273,
  952.         "struct/class/enum/union glue",
  953.         {
  954.             NotDependent {},
  955.             RegularEntry {
  956.                 "• struct",
  957.                 {24,  10, 39, 141},
  958.                 {24, 145, 39, 250},
  959.                 FORMATSTRING_struct0,
  960.                 ignoreCase,
  961.                 "-struct0",
  962.                 "Specify the glue for that point immediately prior to the "
  963.                 "keyword.  The default glue does nothing.",
  964.             },
  965.  
  966.             NotDependent {},
  967.             RegularEntry {
  968.                 "class… • : •",
  969.                 {44,  10, 59, 141},
  970.                 {44, 145, 59, 250},
  971.                 FORMATSTRING_struct1,
  972.                 ignoreCase,
  973.                 "-struct1",
  974.                 "Specify the glue for the ':' in a class definition.  "
  975.                 "The default is to surround it with blanks and set the "
  976.                 "indent to cause all lines following it (until the opening "
  977.                 "curly) to be aligned with the ':'.",
  978.             },
  979.  
  980.             NotDependent {},
  981.             RegularEntry {
  982.                 "class… : … • , •",
  983.                 {64,  10, 79, 141},
  984.                 {64, 145, 79, 250},
  985.                 FORMATSTRING_struct2,
  986.                 ignoreCase,
  987.                 "-struct2",
  988.                 "Specify the glue for the comma separating the base classes "
  989.                 "for a multiple inheritance class.  The default emits the "
  990.                 "comma and places a blank after it.",
  991.             },
  992.  
  993.             NotDependent {},
  994.             RegularEntry {
  995.                 "struct… • { •",
  996.                 {84,  10, 99, 141},
  997.                 {84, 145, 99, 250},
  998.                 FORMATSTRING_struct3,
  999.                 ignoreCase,
  1000.                 "-struct3",
  1001.                 "Specify the glue for the opening curly.  The default is "
  1002.                 "to emit it on the same line as the struct &c and to indent "
  1003.                 "the elements of the struct/enum/class/union.",
  1004.             },
  1005.  
  1006.             NotDependent {},
  1007.             RegularEntry {
  1008.                 "class… {… • public • : •",
  1009.                 {104,  10, 119, 141},
  1010.                 {104, 145, 119, 250},
  1011.                 FORMATSTRING_struct5,
  1012.                 ignoreCase,
  1013.                 "-struct5",
  1014.                 "Specify the glue to emit for member access control keywords "
  1015.                 "such as 'public', 'private', and 'protected'.  The default "
  1016.                 "is to exdent them on a separate line.",
  1017.             },
  1018.  
  1019.             NotDependent {},
  1020.             RegularEntry {
  1021.                 "struct… {… • } •",
  1022.                 {124,  10, 139, 141},
  1023.                 {124, 145, 139, 250},
  1024.                 FORMATSTRING_struct6,
  1025.                 ignoreCase,
  1026.                 "-struct6",
  1027.                 "Specify the glue for the closing curly of a struct.  The "
  1028.                 "default is to exdent the closing curly and request a blank "
  1029.                 "to follow it.",
  1030.             },
  1031.  
  1032.             NotDependent {},
  1033.             RegularEntry {
  1034.                 "struct… {… • } • ;",
  1035.                 {144,  10, 159, 141},
  1036.                 {144, 145, 159, 250},
  1037.                 FORMATSTRING_struct7,
  1038.                 ignoreCase,
  1039.                 "-struct7",
  1040.                 "Specify the glue for the semicolon of struct or enum definition.  "
  1041.                 "The default glue emits two newlines after the ';'",
  1042.             },
  1043.         },
  1044.  
  1045.         /* #9
  1046.         **    Dialog for if/else glue
  1047.         */
  1048.         273,
  1049.         "if glue",
  1050.         {
  1051.             NotDependent {},
  1052.             RegularEntry {
  1053.                 "• if",
  1054.                 {24,  10, 39, 141},
  1055.                 {24, 145, 39, 250},
  1056.                 FORMATSTRING_if0,
  1057.                 ignoreCase,
  1058.                 "-if0",
  1059.                 "Specify the glue to emit prior to the keyword 'if'.  The "
  1060.                 "default is to place the 'if' at the start of a newline."
  1061.             },
  1062.             
  1063.             NotDependent {},
  1064.             RegularEntry {
  1065.                 "if • ( •",
  1066.                 {44,  10, 59, 141},
  1067.                 {44, 145, 59, 250},
  1068.                 FORMATSTRING_if1,
  1069.                 ignoreCase,
  1070.                 "-if1",
  1071.                 "Specify the glue to emit for the opening parenthesis of the "
  1072.                 "test expression.  The default is to separate from the 'if' by "
  1073.                 "a blank."
  1074.             },
  1075.             
  1076.             NotDependent {},
  1077.             RegularEntry {
  1078.                 "if (… • )    •",
  1079.                 {64,  10, 79, 141},
  1080.                 {64, 145, 79, 250},
  1081.                 FORMATSTRING_if2,
  1082.                 ignoreCase,
  1083.                 "-if2",
  1084.                 "Specify the glue for the closing parenthesis of the test "
  1085.                 "expression.  The default is to emit it as is."
  1086.             },
  1087.             
  1088.             NotDependent {},
  1089.             RegularEntry {
  1090.                 "if (…) • ;    •",
  1091.                 {84,  10, 99, 141},
  1092.                 {84, 145, 99, 250},
  1093.                 FORMATSTRING_if3,
  1094.                 ignoreCase,
  1095.                 "-if3",
  1096.                 "Specify the glue for the then-part of an if statement when "
  1097.                 "the then-part is a semicolon.  The default is to indent it on "
  1098.                 "a newline following 'if(…)'"
  1099.             },
  1100.             
  1101.             NotDependent {},
  1102.             RegularEntry {
  1103.                 "if (…) • { •",
  1104.                 {104,  10, 119, 141},
  1105.                 {104, 145, 119, 250},
  1106.                 FORMATSTRING_if4,
  1107.                 ignoreCase,
  1108.                 "-if4",
  1109.                 "Specify the glue for the opening curly of a compound statment "
  1110.                 "ocurring as the then-part of an if statement.  The default is "
  1111.                 "to separate it from the test expression with a single blank, "
  1112.                 "request a newline and indent the body of the compound statement."
  1113.             },
  1114.             
  1115.             NotDependent {},
  1116.             RegularEntry {
  1117.                 "if (…) {… • } •",
  1118.                 {124,  10, 139, 141},
  1119.                 {124, 145, 139, 250},
  1120.                 FORMATSTRING_if5,
  1121.                 ignoreCase,
  1122.                 "-if5",
  1123.                 "Specify the glue for the closing curly of the compound "
  1124.                 "statement when there is no 'else' following it.  The default "
  1125.                 "is to exdent the closing curly on a newline."
  1126.             },
  1127.             
  1128.             NotDependent {},
  1129.             RegularEntry {
  1130.                 "if (…) {… • } • else",
  1131.                 {144,  10, 159, 141},
  1132.                 {144, 145, 159, 250},
  1133.                 FORMATSTRING_if6,
  1134.                 ignoreCase,
  1135.                 "-if6",
  1136.                 "Specify the glue for the closing curly of the compound "
  1137.                 "statement when an 'else' follows it.  The default "
  1138.                 "is to exdent the closing curly on a newline and request a"
  1139.                 "blank before the 'else'."
  1140.             },
  1141.             
  1142.             NotDependent {},
  1143.             RegularEntry {
  1144.                 "if (…) • ?",
  1145.                 {24, 265, 39, 370},
  1146.                 {24, 374, 39, 470},
  1147.                 FORMATSTRING_if7,
  1148.                 ignoreCase,
  1149.                 "-if7",
  1150.                 "Specify the glue for any other sort of statement occurring "
  1151.                 "as the then-part of an if statement.  The default is to "
  1152.                 "indent it on a newline."
  1153.             },
  1154.             
  1155.             NotDependent {},
  1156.             RegularEntry {
  1157.                 "• else • if",
  1158.                 {44, 265, 59, 370},
  1159.                 {44, 374, 59, 470},
  1160.                 FORMATSTRING_else1,
  1161.                 ignoreCase,
  1162.                 "-else1",
  1163.                 "Specify the glue for 'else' when the 'else' is followed by "
  1164.                 "another 'if'.  The default is to emit the 'else if' on a "
  1165.                 "newline."
  1166.             },
  1167.             
  1168.             NotDependent {},
  1169.             RegularEntry {
  1170.                 "• else • { •",
  1171.                 {64, 265, 79, 370},
  1172.                 {64, 374, 79, 470},
  1173.                 FORMATSTRING_else3,
  1174.                 ignoreCase,
  1175.                 "-else3",
  1176.                 "Specify the glue for the 'else' and '{' of a compound statement "
  1177.                 "occurring as the else-part of an if statement.  The default is "
  1178.                 "to emit the 'else' on a newline separated from the '{' by a "
  1179.                 "blank.  The body of the compound statement is indented."
  1180.             },
  1181.             
  1182.             NotDependent {},
  1183.             RegularEntry {
  1184.                 "else {… • } •",
  1185.                 {84, 265, 99, 370},
  1186.                 {84, 374, 99, 470},
  1187.                 FORMATSTRING_else6,
  1188.                 ignoreCase,
  1189.                 "-else6",
  1190.                 "Specify the glue for the closing curly of the compound "
  1191.                 "statement occurring as the else-part of an if statement.  The "
  1192.                 "default is to exdent the closing curly on a line by itself."
  1193.             },
  1194.             
  1195.             NotDependent {},
  1196.             RegularEntry {
  1197.                 "… • else • ?",
  1198.                 {104, 265, 119, 370},
  1199.                 {104, 374, 119, 470},
  1200.                 FORMATSTRING_else4,
  1201.                 ignoreCase,
  1202.                 "-else4",
  1203.                 "Specify the glue for the 'else' when the 'else' is followed "
  1204.                 "by something other than an 'if' or opening curly.  The default "
  1205.                 "is to emit the 'else' on a line by itself with the else-part "
  1206.                 "indented on the line following."
  1207.             },
  1208.         },
  1209.  
  1210.         /* #10
  1211.         **    Dialog for switch glue
  1212.         */
  1213.         273,
  1214.         "switch glue",
  1215.         {
  1216.             NotDependent {},
  1217.             RegularEntry {
  1218.                 "• switch",
  1219.                 {24,  10, 39, 141},
  1220.                 {24, 145, 39, 250},
  1221.                 FORMATSTRING_switch0,
  1222.                 ignoreCase,
  1223.                 "-switch0",
  1224.                 "Specify the glue to emit prior to the switch statement.  The "
  1225.                 "default is to request it to be on a newline."
  1226.             },
  1227.             
  1228.             NotDependent {},
  1229.             RegularEntry {
  1230.                 "switch • ( •",
  1231.                 {44,  10, 59, 141},
  1232.                 {44, 145, 59, 250},
  1233.                 FORMATSTRING_switch1,
  1234.                 ignoreCase,
  1235.                 "-switch1",
  1236.                 "Specify the glue for the open parenthesis of the switch "
  1237.                 "statement's selection expression.  The default is to separate "
  1238.                 "it from the 'switch' by a blank."
  1239.             },
  1240.             
  1241.             NotDependent {},
  1242.             RegularEntry {
  1243.                 "switch (…) • { •",
  1244.                 {64,  10, 79, 141},
  1245.                 {64, 145, 79, 250},
  1246.                 FORMATSTRING_switch2,
  1247.                 ignoreCase,
  1248.                 "-switch2",
  1249.                 "Specify the glue for the open curly of the body of the "
  1250.                 "switch statement.  The default is to cuddle it on the same "
  1251.                 "line as the selection expression, separating it from the ')' "
  1252.                 "with a blank and indenting the body of the switch."
  1253.             },
  1254.             
  1255.             NotDependent {},
  1256.             RegularEntry {
  1257.                 "switch (…) {… • } •",
  1258.                 {84,  10, 99, 141},
  1259.                 {84, 145, 99, 250},
  1260.                 FORMATSTRING_switch7,
  1261.                 ignoreCase,
  1262.                 "-switch7",
  1263.                 "Specify the glue for the close curly of a switch statement.  "
  1264.                 "The default is to exdent it on its own newline."
  1265.             },
  1266.             
  1267.             NotDependent {},
  1268.             RegularEntry {
  1269.                 "• case •",
  1270.                 {104,  10, 119, 141},
  1271.                 {104, 145, 119, 250},
  1272.                 FORMATSTRING_switch3,
  1273.                 ignoreCase,
  1274.                 "-switch3",
  1275.                 "Specify the glue to emit for the 'case' reserved word.  "
  1276.                 "The default is to exdent it on its own newline and follow "
  1277.                 "it with a blank."
  1278.             },
  1279.             
  1280.             NotDependent {},
  1281.             RegularEntry {
  1282.                 "• default •",
  1283.                 {124,  10, 139, 141},
  1284.                 {124, 145, 139, 250},
  1285.                 FORMATSTRING_switch4,
  1286.                 ignoreCase,
  1287.                 "-switch4",
  1288.                 "Specify the glue to emit for the 'default' reserved word.  "
  1289.                 "The default is to exdent the 'default' on its own newline."
  1290.             },
  1291.             
  1292.             NotDependent {},
  1293.             RegularEntry {
  1294.                 "case nnn • : •",
  1295.                 {144,  10, 159, 141},
  1296.                 {144, 145, 159, 250},
  1297.                 FORMATSTRING_switch5,
  1298.                 ignoreCase,
  1299.                 "-switch5",
  1300.                 "Specify the glue for the colon following any case label, "
  1301.                 "including 'default'.  The default is to cuddle it with the "
  1302.                 "token on its left and request a newline to follow it."
  1303.             },
  1304.         },
  1305.  
  1306.         /* #11
  1307.         **    Dialog for for glue
  1308.         */
  1309.         273,
  1310.         "for glue",
  1311.         {
  1312.             NotDependent {},
  1313.             RegularEntry {
  1314.                 "• for",
  1315.                 {24,  10, 39, 141},
  1316.                 {24, 145, 39, 250},
  1317.                 FORMATSTRING_for0,
  1318.                 ignoreCase,
  1319.                 "-for0",
  1320.                 "Specify the glue to emit prior to a for statement.  The "
  1321.                 "default is to request it to be on a newline."
  1322.             },
  1323.             
  1324.             NotDependent {},
  1325.             RegularEntry {
  1326.                 "for • ( •",
  1327.                 {44,  10, 59, 141},
  1328.                 {44, 145, 59, 250},
  1329.                 FORMATSTRING_for1,
  1330.                 ignoreCase,
  1331.                 "-for1",
  1332.                 "Specify the glue to emit for the opening parenthesis of the "
  1333.                 "test expression of a for statement.  The default is to emit "
  1334.                 "it as is."
  1335.             },
  1336.             
  1337.             NotDependent {},
  1338.             RegularEntry {
  1339.                 "for (… • ;",
  1340.                 {64,  10, 79, 141},
  1341.                 {64, 145, 79, 250},
  1342.                 FORMATSTRING_for3,
  1343.                 ignoreCase,
  1344.                 "-for3",
  1345.                 "Specify the glue for semicolon in the test "
  1346.                 "expression of a for statement.  The default is to cuddle it"
  1347.                 "with the previous token and request a blank to follow it."
  1348.             },
  1349.             
  1350.             NotDependent {},
  1351.             RegularEntry {
  1352.                 "for (… • ) •",
  1353.                 {84,  10, 99, 141},
  1354.                 {84, 145, 99, 250},
  1355.                 FORMATSTRING_for4,
  1356.                 ignoreCase,
  1357.                 "-for4",
  1358.                 "Specify the glue for the close parenthesis of the test "
  1359.                 "expression of a for statement.  The default is to just "
  1360.                 "emit it as is."
  1361.             },
  1362.             
  1363.             NotDependent {},
  1364.             RegularEntry {
  1365.                 "for (…) • { •",
  1366.                 {104,  10, 119, 141},
  1367.                 {104, 145, 119, 250},
  1368.                 FORMATSTRING_for5,
  1369.                 ignoreCase,
  1370.                 "-for5",
  1371.                 "Specify the glue for the open curly of a compound statement "
  1372.                 "for-body.  The default is to separate it from the test "
  1373.                 "expression with a single blank and indent the body."
  1374.             },
  1375.             
  1376.             NotDependent {},
  1377.             RegularEntry {
  1378.                 "for (…) {… • } •",
  1379.                 {124,  10, 139, 141},
  1380.                 {124, 145, 139, 250},
  1381.                 FORMATSTRING_for8,
  1382.                 ignoreCase,
  1383.                 "-for8",
  1384.                 "Specify the glue for the close curly of the compound statement "
  1385.                 "for-body.  The default is to exdent it on its own newline."
  1386.             },
  1387.             
  1388.             NotDependent {},
  1389.             RegularEntry {
  1390.                 "for (…) • ; •",
  1391.                 {144,  10, 159, 141},
  1392.                 {144, 145, 159, 250},
  1393.                 FORMATSTRING_for6,
  1394.                 ignoreCase,
  1395.                 "-for6",
  1396.                 "Specify the glue for an empty for-body.  The default is to "
  1397.                 "indent the semicolon on its own newline."
  1398.             },
  1399.             
  1400.             NotDependent {},
  1401.             RegularEntry {
  1402.                 "for (…) • ?",
  1403.                 {24, 265, 39, 370},
  1404.                 {24, 374, 39, 470},
  1405.                 FORMATSTRING_for7,
  1406.                 ignoreCase,
  1407.                 "-for7",
  1408.                 "Specify the glue to emit prior to an arbitrary for body "
  1409.                 "statement.  The default is to indent the statement on its "
  1410.                 "own newline."
  1411.             },
  1412.         },
  1413.  
  1414.         /* #12
  1415.         **    Dialog for while/do glue
  1416.         */
  1417.         273,
  1418.         "while/do glue",
  1419.         {
  1420.             NotDependent {},
  1421.             RegularEntry {
  1422.                 "• while",
  1423.                 {24,  10, 39, 141},
  1424.                 {24, 145, 39, 250},
  1425.                 FORMATSTRING_while0,
  1426.                 ignoreCase,
  1427.                 "-while0",
  1428.                 "Specify the glue to emit prior to the 'while'.  The default "
  1429.                 "is to request the while on its own line."
  1430.             },
  1431.             
  1432.             NotDependent {},
  1433.             RegularEntry {
  1434.                 "while • ( •",
  1435.                 {44,  10, 59, 141},
  1436.                 {44, 145, 59, 250},
  1437.                 FORMATSTRING_while1,
  1438.                 ignoreCase,
  1439.                 "-while1",
  1440.                 "Specify the glue to emit for the opening parenthesis of the "
  1441.                 "test expression of a while statement.  The default is to put "
  1442.                 "it on the same line as the 'while' with a blank separating "
  1443.                 "the two."
  1444.             },
  1445.             
  1446.             NotDependent {},
  1447.             RegularEntry {
  1448.                 "while (… • ) •",
  1449.                 {64,  10, 79, 141},
  1450.                 {64, 145, 79, 250},
  1451.                 FORMATSTRING_while6,
  1452.                 ignoreCase,
  1453.                 "-while6",
  1454.                 "Specify the glue for the close parenthesis of the test "
  1455.                 "expression.  The default is to emit it as is."
  1456.             },
  1457.             
  1458.             NotDependent {},
  1459.             RegularEntry {
  1460.                 "while (…) • ; •",
  1461.                 {84,  10, 99, 141},
  1462.                 {84, 145, 99, 250},
  1463.                 FORMATSTRING_while3,
  1464.                 ignoreCase,
  1465.                 "-while3",
  1466.                 "Specify the glue for an empty while body.  The default is to "
  1467.                 "place it indented on its own newline."
  1468.             },
  1469.             
  1470.             NotDependent {},
  1471.             RegularEntry {
  1472.                 "while (…) • { •",
  1473.                 {104,  10, 119, 141},
  1474.                 {104, 145, 119, 250},
  1475.                 FORMATSTRING_while2,
  1476.                 ignoreCase,
  1477.                 "-while2",
  1478.                 "Specify the glue for the opening curly of a compound statement "
  1479.                 "while body.  The default is to separate it from the test expression "
  1480.                 "by a single blank and indent the body."
  1481.             },
  1482.             
  1483.             NotDependent {},
  1484.             RegularEntry {
  1485.                 "while (…) {… • } •",
  1486.                 {124,  10, 139, 141},
  1487.                 {124, 145, 139, 250},
  1488.                 FORMATSTRING_while5,
  1489.                 ignoreCase,
  1490.                 "-while5",
  1491.                 "Specify the glue for the closing curly of a compound statement "
  1492.                 "while body.  The default is to exdent it on its own newline."
  1493.             },
  1494.             
  1495.             NotDependent {},
  1496.             RegularEntry {
  1497.                 "while (…) • ?",
  1498.                 {144,  10, 159, 141},
  1499.                 {144, 145, 159, 250},
  1500.                 FORMATSTRING_while4,
  1501.                 ignoreCase,
  1502.                 "-while4",
  1503.                 "Specify the glue for any other statement as the body of a "
  1504.                 "while.  The default is to indent the statement on its own "
  1505.                 "newline."
  1506.             },
  1507.             
  1508.             NotDependent {},
  1509.             RegularEntry {
  1510.                 "• do",
  1511.                 {24, 265, 39, 370},
  1512.                 {24, 374, 39, 470},
  1513.                 FORMATSTRING_do0,
  1514.                 ignoreCase,
  1515.                 "-do0",
  1516.                 "Specify the glue to emit prior to the 'do' of a do…while.  "
  1517.                 "The default is to begin the statement on a newline."
  1518.             },
  1519.             
  1520.             NotDependent {},
  1521.             RegularEntry {
  1522.                 "do • ;",
  1523.                 {44, 265, 59, 370},
  1524.                 {44, 374, 59, 470},
  1525.                 FORMATSTRING_do1,
  1526.                 ignoreCase,
  1527.                 "-do1",
  1528.                 "Specify the glue for a do…while body consisting of a single "
  1529.                 "semicolon.  The default is to indent it on its own line."
  1530.             },
  1531.             
  1532.             NotDependent {},
  1533.             RegularEntry {
  1534.                 "do • { •",
  1535.                 {64, 265, 79, 370},
  1536.                 {64, 374, 79, 470},
  1537.                 FORMATSTRING_do2,
  1538.                 ignoreCase,
  1539.                 "-do2",
  1540.                 "Specify the glue for the opening curly of a compound statement "
  1541.                 "body in a do…while.  The default is to request a blank and "
  1542.                 "put it on the same line as the 'do'.  The body will be indented."
  1543.             },
  1544.             
  1545.             NotDependent {},
  1546.             RegularEntry {
  1547.                 "do {… • } •",
  1548.                 {84, 265, 99, 370},
  1549.                 {84, 374, 99, 470},
  1550.                 FORMATSTRING_do4,
  1551.                 ignoreCase,
  1552.                 "-do4",
  1553.                 "Specify the glue for the closing curly of the compound "
  1554.                 "statement body of a do…while.  The default is to exdent the "
  1555.                 "curly, request a blank, and cuddle the 'while' on the same "
  1556.                 "line"
  1557.             },
  1558.             
  1559.             NotDependent {},
  1560.             RegularEntry {
  1561.                 "do • ?",
  1562.                 {104, 265, 119, 370},
  1563.                 {104, 374, 119, 470},
  1564.                 FORMATSTRING_do3,
  1565.                 ignoreCase,
  1566.                 "-do3",
  1567.                 "Specify the glue prior to a non-compound statement.  The "
  1568.                 "default is to indent the statement on a newline."
  1569.             },
  1570.             
  1571.             NotDependent {},
  1572.             RegularEntry {
  1573.                 "do… • while",
  1574.                 {124, 265, 139, 370},
  1575.                 {124, 374, 139, 470},
  1576.                 FORMATSTRING_do5,
  1577.                 ignoreCase,
  1578.                 "-do5",
  1579.                 "Specify the glue to emit for the 'while' in a do…while.  The "
  1580.                 "default is to place the 'while' on a newline."
  1581.             },
  1582.             
  1583.             NotDependent {},
  1584.             RegularEntry {
  1585.                 "do…while • ( •",
  1586.                 {144, 265, 159, 370},
  1587.                 {144, 374, 159, 470},
  1588.                 FORMATSTRING_do6,
  1589.                 ignoreCase,
  1590.                 "-do6",
  1591.                 "Specify the glue for the open parenthesis of the test "
  1592.                 "expression of the 'do'.  The default is to emit a blank and "
  1593.                 "then the open parenthesis."
  1594.             },
  1595.         },
  1596.     },
  1597. };
  1598.